package com.example.springboottpl.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.springboottpl.dao.DictDataDao;
import com.example.springboottpl.dao.DictTypeDao;
import com.example.springboottpl.entity.DictDataBean;
import com.example.springboottpl.entity.DictTypeBean;
import com.example.springboottpl.service.DictDataService;
import com.example.springboottpl.util.Result;
import com.example.springboottpl.util.ResultPage;
import com.example.springboottpl.vo.common.DeleteBatchReqVo;
import com.example.springboottpl.vo.common.QueryDetailReqVo;
import com.example.springboottpl.vo.common.UpdateStatusReq;
import com.example.springboottpl.vo.req.DictDataReqVo;
import com.example.springboottpl.vo.req.QueryDictDataReqVo;
import com.example.springboottpl.vo.resp.DictDataRespVo;

/**
 * 描述：字典数据
 * 作者：刘飞华
 * 日期：2025/01/10 15:34:34
 */
@Service
public class DictDataServiceImpl implements DictDataService {

    @Autowired
    private DictDataDao dictDataDao;

    @Autowired
    private DictTypeDao dictTypeDao;

    /**
     * 添加字典数据
     *
     * @param dictData 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<Integer> addDictData(DictDataReqVo dictData) {
        String dictType = dictData.getDictType();//字典类型
        String dictLabel = dictData.getDictLabel();//字典标签
        String dictValue = dictData.getDictValue();//字典键值

        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery()
                                            .eq(DictTypeBean::getDictType, dictType)) == 0) {
            return Result.error("字典类型不存在");
        }

        if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                            .eq(DictDataBean::getDictLabel, dictLabel)
                                            .eq(DictDataBean::getDictType, dictType)) > 0) {
            return Result.error("字典标签已存在");
        }

        if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                            .eq(DictDataBean::getDictValue, dictValue)
                                            .eq(DictDataBean::getDictType, dictType)) > 0) {
            return Result.error("字典键值已存在");
        }

        DictDataBean bean = new DictDataBean();
        bean.setDictSort(dictData.getDictSort()); //字典排序
        bean.setDictLabel(dictLabel); //字典标签
        bean.setDictValue(dictValue); //字典键值
        bean.setDictType(dictType); //字典类型
        bean.setCssClass(dictData.getCssClass()); //样式属性（其他样式扩展）
        bean.setListClass(dictData.getListClass()); //表格回显样式
        bean.setIsDefault(dictData.getIsDefault()); //是否默认（Y是 N否）
        bean.setStatus(dictData.getStatus()); //状态（0：停用，1:正常）
        bean.setRemark(dictData.getRemark()); //备注

        int i = dictDataDao.insert(bean);
        return Result.success(i);
    }

    /**
     * 删除字典数据
     *
     * @param dictData 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<Integer> deleteDictData(DeleteBatchReqVo dictData) {
        int i = dictDataDao.deleteByIds(dictData.getIds());
        return Result.success(i);
    }

    /**
     * 更新字典数据
     *
     * @param dictData 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<Integer> updateDictData(DictDataReqVo dictData) {
        Long id = dictData.getId();//字典编码
        String dictType = dictData.getDictType();//字典类型
        String dictLabel = dictData.getDictLabel();//字典标签
        String dictValue = dictData.getDictValue();//字典键值

        if (dictTypeDao.selectCount(Wrappers.<DictTypeBean>lambdaQuery()
                                            .eq(DictTypeBean::getDictType, dictType)) == 0) {
            return Result.error("字典类型不存在");
        }


        if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                            .eq(DictDataBean::getId, id)) == 0) {
            return Result.error("字典数据不存在");
        }

        if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                            .eq(DictDataBean::getDictLabel, dictLabel)
                                            .eq(DictDataBean::getDictType, dictType)
                                            .ne(DictDataBean::getId, id)) > 0) {
            return Result.error("字典标签已存在");
        }

        if (dictDataDao.selectCount(Wrappers.<DictDataBean>lambdaQuery()
                                            .eq(DictDataBean::getDictValue, dictValue)
                                            .eq(DictDataBean::getDictType, dictType)
                                            .ne(DictDataBean::getId, id)) > 0) {
            return Result.error("字典键值已存在");
        }


        DictDataBean bean = new DictDataBean();
        bean.setId(dictData.getId());//字典编码
        bean.setDictSort(dictData.getDictSort()); //字典排序
        bean.setDictLabel(dictLabel); //字典标签
        bean.setDictValue(dictValue); //字典键值
        bean.setDictType(dictType); //字典类型
        bean.setCssClass(dictData.getCssClass()); //样式属性（其他样式扩展）
        bean.setListClass(dictData.getListClass()); //表格回显样式
        bean.setIsDefault(dictData.getIsDefault()); //是否默认（Y是 N否）
        bean.setStatus(dictData.getStatus()); //状态（0：停用，1:正常）
        bean.setRemark(dictData.getRemark()); //备注

        int i = dictDataDao.updateById(bean);
        return Result.success(i);
    }

    /**
     * 更新字典数据状态
     *
     * @param dictData 请求参数
     * @return int
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<Integer> updateDictDataStatus(UpdateStatusReq dictData) {

        int i = dictDataDao.update(Wrappers.<DictDataBean>lambdaUpdate()
                                           .in(DictDataBean::getId, dictData.getIds())
                                           .set(DictDataBean::getStatus, dictData.getStatus()));
        return Result.success(i);
    }

    /**
     * 查询字典数据详情
     *
     * @param dictData 请求参数
     * @return DictDataResp
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<DictDataRespVo> queryDictDataDetail(QueryDetailReqVo dictData) {

        DictDataBean dataBean = dictDataDao.selectById(dictData.getId());
        if (dataBean == null) {
            return Result.error("字典数据不存在");
        }
        DictDataRespVo resp = new DictDataRespVo();
        resp.setId(dataBean.getId());//字典编码
        resp.setDictSort(dataBean.getDictSort());//字典排序
        resp.setDictLabel(dataBean.getDictLabel());//字典标签
        resp.setDictValue(dataBean.getDictValue());//字典键值
        resp.setDictType(dataBean.getDictType());//字典类型
        resp.setCssClass(dataBean.getCssClass());//样式属性（其他样式扩展）
        resp.setListClass(dataBean.getListClass());//表格回显样式
        resp.setIsDefault(dataBean.getIsDefault());//是否默认（Y是 N否）
        resp.setStatus(dataBean.getStatus());//状态（0：停用，1:正常）
        resp.setRemark(dataBean.getRemark());//备注
        resp.setCreateTime(dataBean.getCreateTime());//创建时间
        resp.setUpdateTime(dataBean.getUpdateTime());//修改时间

        return Result.success(resp);
    }

    /**
     * 查询字典数据列表
     *
     * @param dictData 请求参数
     * @return DictDataResp
     * @author 刘飞华
     * @date: 2025/01/10 15:34:34
     */
    @Override
    public Result<ResultPage<DictDataRespVo>> queryDictDataList(QueryDictDataReqVo dictData) {
        LambdaQueryWrapper<DictDataBean> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.like(dictData.getDictType() != null, DictDataBean::getDictType, dictData.getDictType());
        queryWrapper.like(dictData.getDictLabel() != null, DictDataBean::getDictLabel, dictData.getDictLabel());
        queryWrapper.eq(dictData.getStatus() != null, DictDataBean::getStatus, dictData.getStatus());

        Page<DictDataBean> page = dictDataDao.selectPage(new Page<>(dictData.getPageNo(), dictData.getPageSize()), queryWrapper);

        List<DictDataRespVo> list = new ArrayList<>();

        for (DictDataBean dataBean : page.getRecords()) {
            DictDataRespVo resp = new DictDataRespVo();
            resp.setId(dataBean.getId());//字典编码
            resp.setDictSort(dataBean.getDictSort());//字典排序
            resp.setDictLabel(dataBean.getDictLabel());//字典标签
            resp.setDictValue(dataBean.getDictValue());//字典键值
            resp.setDictType(dataBean.getDictType());//字典类型
            resp.setCssClass(dataBean.getCssClass());//样式属性（其他样式扩展）
            resp.setListClass(dataBean.getListClass());//表格回显样式
            resp.setIsDefault(dataBean.getIsDefault());//是否默认（Y是 N否）
            resp.setStatus(dataBean.getStatus());//状态（0：停用，1:正常）
            resp.setRemark(dataBean.getRemark());//备注
            resp.setCreateTime(dataBean.getCreateTime());//创建时间
            resp.setUpdateTime(dataBean.getUpdateTime());//修改时间

            list.add(resp);
        }

        return Result.success(new ResultPage<>(list, page.getCurrent(), page.getSize(), page.getTotal()));

    }
}